<%@ include file="/common/taglibs.jsp"%>
<!--分页查询共用的页面-->
<%@ include file="/common/common.jsp"%>
<%@ include file="/common/dateUtil.jsp"%>
<%@ page language="java" pageEncoding="UTF-8"%>
<head>
    <!--载入百度地图所需控件-->
<script type="text/javascript" src="http://api.map.baidu.com/api?v=2.0&ak=8x3ue1dIcaF6yA8LxvrIe8ev"></script>

<!--窗口类-->
<script type="text/javascript" src="<%=ApplicationPath%>/js/InfoWindow.js"></script>	

<script type="text/javascript" src="<%=ApplicationPath%>/js/util/insertGpaData.js?v=8503022"></script>	

<style>
/*右侧工具区的最外层样式*/
.ins_m_toolParDiv_css{
    width:100%;
    /* height:100%; */
    display: flex;
    flex-direction: column;
    justify-content: flex-start;
    align-items: center;
}

.ins_m_toolParDiv_css > div{
    width:96%;
    margin-top:10px;
    display: flex;
    /* justify-content: flex-start; */
    align-items: center;
}

/*输入框边框样式*/
.ins_m_inputImpBorder_css{
    height: 24px !important;
    border: 1px solid cornflowerblue !important;
    border-radius: 3px;
}

</style>

<script>

/////////////////////////////////////////////////////////////////变量
var baiduMap = null;//百度地图对象
var baiduDriving = null;//百度驾驶路径规划对象
var ins_m = {
    data:{},//定义数据相关
};
ins_m.debug = true;
ins_m.data.pList = [];//定义规划后的坐标列表 
ins_m.data.miles = 0;//初始化起点终点之间的规划距离，默认为0
ins_m.data.times = 0;//定义两点之间的时间间隔，默认为0
ins_m.data.resList = [];//定义经过离散取点并格式化数据之后的可用数据列表
ins_m.data.gpsBasicData = {};//定义gps数据基础数据为空对象，基础数据中包含车牌号等信息，通过点击起点数据获取
ins_m.data.calParam = {};//定义计算所需参数
ins_m.data.plateColor = -1;
ins_m.data.tooFastValue = 160;//定义漂移速度标准，为160(km/h)
ins_m.data.speedMsg  = "";//定义车速校验时的信息缓存

//轨迹计算截取所需参数偏移量offset
ins_m.data.offset = {};
ins_m.data.offset.time = 30;//车机时间两点之间的间隔时间
ins_m.data.offset.timeOft = 6;//车机时间偏移量,即30+-3
ins_m.data.offset.directOft = 60 ;//方向偏移量，例：方向为20 ，实际偏移量为20+- 30
ins_m.data.offset.altitudeOft = 30;//海拔偏移量，例：海拔为20，实际海拔为：20 ---70，单项偏移
ins_m.data.offset.speedOft = 60;//速度偏移量,例：速度为35，实际速度为35-18 --- 35+42
ins_m.data.offset.createDateNumsOft = 60;//定义每60个偏移一秒

ins_m.flg = {};//定义标记保存对象
ins_m.flg.calFlg = 0;//计算标记
ins_m.flg.insertFlg = 0;//插入标记
ins_m.flg.searchFlg = 0;//查询标记

ins_m.msgTimer = "ins_m_OneTimer_msg";//定义信息相关定时器名称


//////自动补数据标记
ins_m.flg.autoInsertFlg = false;
ins_m.flg.autoInsertSpeed = 80;
ins_m.flg.autoEndHours = 12;//定义补数据12小时之内的不允许补
ins_m.flg.maxSpeedFlg = 120;//定义最高限速为120，超过不补

ins_m.flg.validPointFlg = true;//两点之间是否存在有效数据，false表示不存在


////////按时间截取补轨迹相关
ins_m.quantumData = {};
ins_m.quantumData.quantumList = [];//定义时间段轨迹列表
ins_m.quantumData.pointQuantumValue = 0;//截取坐标点的段数
ins_m.quantumData.insertIndex = -1;//定义正在插入的索引，默认为-1；


///////仅转发数据功能相关
ins_m.onlyTrans = {};
ins_m.onlyTrans.cache = {};

/////////////////////////////////////////////////////////////////初始化控件
//接口，初始化所有控件
ins_m.initDivs = function(){
    ins_m.initCreateDateDiv();

    ins_m.initBaiduMap();
    ins_m.initSlctDataDiv();
    ins_m.initGpsDatadiv();
}

//初始化参数设置区-->接收时间控件
ins_m.initCreateDateDiv = function(){
    $("#ins_m_cal_createDate").datetimebox("setValue",Utility.now());

    //设置查询开始时间
    let start = new Date().getTime() - 1000 * 60 * 60 * 24;
    $("#ins_m_startDate").datetimebox("setValue",Utility.dateToString(new Date(start)));
    
}

/*
初始化百度地图控件
*/
ins_m.initBaiduMap = function(){
    var baiduMap = new BMap.Map("ins_m_baiduMap_Div");
    baiduMap.centerAndZoom(new BMap.Point(116.404, 39.915), 11);
    baiduMap.enableScrollWheelZoom(true);
    //路径计算对象
    baiduDriving = new BMap.DrivingRoute(baiduMap, { renderOptions: { map: baiduMap, autoViewport: true } });
    baiduDriving.setSearchCompleteCallback(ins_m.baiduDrivingCompleteCallback);
}


//初始化起点终点选择数据框
ins_m.initSlctDataDiv = function(){
    $("#ins_m_slctDatagrid_tab").datagrid({
        frozenColumns:[[
        { title: '操作', field: 'operation',formatter:ins_m.slct_formatOperation, width: 70, minWidth: 70, align: 'center' },
        ]],
        columns: [[
            { title: '车牌号', field: 'plateNo', width: 70, minWidth: 70, align: 'center' },
            { title: '车机时间', field: 'sendTime', width: 130, minWidth: 130, align: 'center' },
            { title: '接收时间', field: 'createDate', width: 130, minWidth: 130, align: 'center' },
            { title: '经度', field: 'longitude', width: 100, minWidth: 80, align: 'center' },
            { title: '纬度', field: 'latitude', width: 100, minWidth: 80, align: 'center' },
            { title: '车速(Km/h)', field: 'velocity', width: 70, minWidth: 80, align: 'center' },
        ]],
        // width:"100%",
        // height:178,
        striped: true,//行条纹化
        pagination: false,//分页
        singleSelect: true,//只允许选中一行
        rownumbers: true,//显示行号
        checkOnSelect: false,//勾选即选中
        selectOnCheck: false,//选中即勾选
    });
}

//初始化gps数据表格datagrid
ins_m.initGpsDatadiv = function(){
    // this.outDebug("开始初始化datagrid控件");
    $("#ins_m_calData_tab").datagrid({
        columns: [[
            // { title: '序号', field: 'index', width: 50, minWidth: 50, align: 'center' },
            // { title: '原下标', field: 'oldIndex', width: 50, minWidth: 50, align: 'center' },
            { title: '车牌号', field: 'plateNo', width: 70, minWidth: 70, align: 'center' },
            { title: '经度', field: 'longitude', width: 90, minWidth: 80, align: 'center' },
            { title: '纬度', field: 'latitude', width: 90, minWidth: 80, align: 'center' },
            { title: '距离(米)', field: 'distance', width: 70, minWidth: 70, align: 'center' },
            { title: '实际车速', field: 'realSpeed', width: 70, minWidth: 70, align: 'center' },
            { title: 'gps车速', field: 'speed', width: 70, minWidth: 70, align: 'center' },
            { title: '车机车速', field: 'recSpeed', width: 70, minWidth: 70, align: 'center' },
            { title: '方向', field: 'direction', width: 60, minWidth: 60, align: 'center' },
            { title: '海拔', field: 'altitude', width: 60, minWidth: 60, align: 'center' },
            { title: '总里程', field: 'mileage', width: 70, minWidth: 70, align: 'center' },
            { title: '车机时间', field: 'sendTime', width: 130, minWidth: 110, align: 'center' },
            { title: '接收时间', field: 'createDate', width: 130, minWidth: 110, align: 'center' },
            //下面三个字段暂不需要
            //{ title: '颜色', field: 'plateColor', width: 45,minWidth:60 },
            // { title: 'Sim卡号', field: 'simNo', width: 105,minWidth:120 },
            // { title: 'id', field: 'id', width: 0,minWidth:0 }
        ]],
        // width:"100%",
		// height:"100%",
		pagination:false,
		singleSelect:true,
		rownumbers:true,
		striped:true,
		checkOnSelect: false,
        selectOnCheck: false,
        onClickRow:function(rowIndex,rowData){
            ins_m.outDebug("选择一行数据,索引：" + rowIndex + " , 数据为：" ,rowData);
        },
    });
}


/////////////////////////////////////////////////////////////////初始化变量

//接口，初始化所有数据
ins_m.initDatas = function(){
    ins_m.initCalData();
    ins_m.initAutoInsertData();
}

//初始化计算相关数据
ins_m.initCalData = function(){
    ins_m.data.pList = [];
    ins_m.data.miles = 0;
    ins_m.data.times = 0;
    ins_m.data.resList = [];
    ins_m.data.calParam = {};
    // ins_m.data.plateColor = 0;
}


//初始化插入数据相关
ins_m.initAutoInsertData = function(){
    let that = this;
    let disId = "${disId}";
    let type = "${type}";
    DataUtil.outDebug("disId = " + disId + " , type = " + type);
    if(disId != "0"){
        let param = {};
        param.Id = disId;
        param.queryId = "dataProcess.selectOneDiscontinuityData";
        let url = globalConfig.webPath + "/basicSlctAction/basicSelectData.action";
        Utility.getAjaxData(url,JSON.stringify(param),function(data){
            DataUtil.outDebug("接收到自动补的数据" , data);
            if(data.success){
                if(!DataUtil.isDefined(data.data) && data.data.length > 0){
                    that.insertAutoParam(data.data[0]);
                    that.checkGpsValidPoints(data.data[0]);//校验有效数据
                    if(type == "1"){
                        that.flg.autoInsertFlg = true;
                        that.getBaiduRoute();//------------------------------开始规划数据
                        //设置标记
                        ins_m.initAutoInsertFlg();
                    }
                }else{
                    that.showMsg("获取自动补数据所需参数失败！");   
                }
            }else{
                that.showMsg("自动补数据失败：" + data.message);
            }
        });
    }
  
}

//校验插入数据的合法性
ins_m.checkAutoInsertParam = function(){
    let msg = "";
    try {
        let startTime = new Date($("#ins_m_cal_startDate").datetimebox("getValue"));
        let start = startTime.getTime();
        let endTime = new Date($("#ins_m_cal_endDate").datetimebox("getValue"));
        let end = endTime.getTime();
        let nowTime = new Date();
        let now = nowTime.getTime();
        ins_m.outDebug("startTime : " + Utility.dateToString(startTime));
        ins_m.outDebug("endTime : " + Utility.dateToString(endTime));
        //校验开始时间
        if(end <= start){
            msg += "截止时间不能小于或者等于开始时间！ "
        }
    
        //校验时间是否大于4小时
        if((end - start - 1000 * 60 * 60 *4) > 0){
            msg += "起止时间大于4小时，预防疲劳驾驶！ ";
        }
        
        //校验两个时间是否包含凌晨两点到凌晨5点之间的时间
        let startHour = startTime.getHours();
        let endHour = endTime.getHours();
        if (msg == "") {
            if (startHour >= 2 && startHour < 5) {
                msg += "开始时间在凌晨两点到五点之间！ ";
            }
    
            if (endHour >= 2 && endHour < 5) {
                msg += "结束时间在凌晨两点到五点之间！ ";
            }
    
            //当天
            if (startTime.getDate() == endTime.getDate()) {
                if (startHour < 5 && endHour >= 2) {
                    msg += "两点之间的时间包含凌晨两点到五点的时间！ ";
                }
            } else if (endTime.getDate() > startTime.getDate()) {
                if (endHour >= 2) {
                    msg += "隔天数据，两点之间的时间包含凌晨两点到五点的时间！ ";
                }
            }
        }


        //校验车机时间是否为当前时间之前
        if(start > now || end > now){
            msg += "车机开始时间和结束时间不可以超过当前时间！ ";
        }

        //校验车机开始时间是否为20小时之前,分段插入不校验车机结束时间
        let strStart = "";
        if((now - start - 1000 * 60 * 60 * 20) >= 0){
            strStart += "车机开始时间不能设置为20小时之前！";
        }
        if(ins_m.quantumData.quantumList.length > 0){
            strStart = "";
        }
        msg += strStart;

        //校验车机结束时间不能为12小时之内
        let type = "${type}";
        
        let str1 = "";
        if (now - end < 1000 * 60 * 60 * ins_m.flg.autoEndHours) {
            str1 += "车机结束时间在12小时之内的，不建议补轨迹！";
        }
        //自动插入不校验车机结束时间,分段插入不校验车机结束时间
        if(type == "1" || ins_m.quantumData.quantumList.length > 0){
            str1 = "";
        }
        msg += str1;
        
    } catch (error) {
        msg += "校验时间参数失败！";
    }

    return msg;
}

//插入自动补数据所需参数
ins_m.insertAutoParam = function(data){
    DataUtil.outDebug('开始设置参数数据');
    try {
        let lng1 = isNaN(parseFloat(data.upLongitude)) ? 0 : parseFloat(data.upLongitude);
        let lat1 = isNaN(parseFloat(data.upLatitude)) ? 0 : parseFloat(data.upLatitude);

        let lng2 = isNaN(parseFloat(data.longitude)) ? 0 : parseFloat(data.longitude);
        let lat2 = isNaN(parseFloat(data.latitude)) ? 0 : parseFloat(data.latitude);
        
        if(lng1 > 0 && lat1 > 0 && lng2 > 0 && lat2 > 0){
            let p1Gcj02 = DataUtil.wgs84togcj02(lng1, lat1);
            let p2Gcj02 = DataUtil.wgs84togcj02(lng2, lat2);
        $("#ins_m_cal_plateNo").val((DataUtil.isDefined(data.plateNo) ? "":data.plateNo));
        $("#ins_m_cal_simNo").val((DataUtil.isDefined(data.simNo) ? "":data.simNo));
    
        $("#ins_m_point1_lng_input").val(p1Gcj02[0].toFixed(6));
        $("#ins_m_point1_lat_input").val(p1Gcj02[1].toFixed(6));
    
        $("#ins_m_point2_lng_input").val(p2Gcj02[0].toFixed(6));
        $("#ins_m_point2_lat_input").val(p2Gcj02[1].toFixed(6));
    
        $("#ins_m_cal_startDate").datetimebox("setValue",(DataUtil.isDefined(data.upSendTime) ? "":data.upSendTime));
        $("#ins_m_cal_endDate").datetimebox("setValue",(DataUtil.isDefined(data.sendTime) ? "":data.sendTime));
        }else{
            ins_m.showMsg("获取经纬度参数失败，无法自动插入数据!");
        }

        //初始化基本数据
        this.data.gpsBasicData = data;
        
        
    } catch (error) {
        DataUtil.outError("插入自动补数据所需参数失败：" + error);
    }
}

//初始化insertFlg标记，防止自动补传没有被初始化
ins_m.initAutoInsertFlg = function(){
    // ins_m.outDebug("开启定时器，准备初始化自动转发标记 ， 时间：" + Utility.now());
    $(document).stopTime("autoInsertFlg850302111");
    $(document).oneTime("10s","autoInsertFlg850302111",function(){
        //10秒后，强制设置自动插入标记为false
        // ins_m.showMsg("设置自动转发标记为false ， 时间：" + Utility.now());
        ins_m.flg.autoInsertFlg = false;
    });
}


//校验当前轨迹间有没有无效数据
ins_m.checkGpsValidPoints = function(data){
    let that = this;
    that.outDebug("开始校验不连续轨迹两点之间的有效数据!");
    let param = {};
    param.plateNo = DataUtil.isDefined(data.plateNo) ? "":data.plateNo;
    param.upSendTime = DataUtil.isDefined(data.upSendTime) ? "":data.upSendTime; 
    param.sendTime = DataUtil.isDefined(data.sendTime) ? "":data.sendTime;
    if(param.plateNo != "" && param.upSendTime != "" && param.sendTime != ""){
        param.valid = 1;
        param.queryId = "dataProcess.selectGpsDataBetween2Points";
        let url = globalConfig.webPath + '/basicSlctAction/basicSelectData.action';
            Utility.getAjaxData(url,JSON.stringify(param),function(data){
                that.outDebug("接收到校验有效数据轨迹点：" , data);
                if(data.success){
                    if(!DataUtil.isDefined(data.data[0])){
                        if(!DataUtil.isDefined(data.data[0].nums)){
                            let nums = data.data[0].nums;
                            that.outDebug("当前不连续轨迹点之间的有效数据数量为：" + nums);
                            if(nums > 0){
                                that.flg.validPointFlg = true;//修改标记
                            }else{
                                that.flg.validPointFlg = false;
                            }
                        }
                    }
                    that.outDebug("校验有效数据点标记为：" + that.flg.validPointFlg);
                }else{
                    that.showMsg(data.message);
                }
            });
    }
}



/////////////////////////////////////////////////////////////////路径规划

//规划路径数据
ins_m.calRoutdatas = function(p1lng,p1lat,p2lng,p2lat){
    //起点
    let p1Gcj02 = DataUtil.wgs84togcj02(p1lng, p1lat);
    // this.outDebug("p1Gcj02 = ", p1Gcj02);
    let p1Bd09 = DataUtil.gcj02tobd09(parseFloat(p1Gcj02[0]), parseFloat(p1Gcj02[1]));
    // this.outDebug("p1Bd09 = ", p1Bd09);
    //终点
    let p2Gcj02 = DataUtil.wgs84togcj02(p2lng, p2lat);
    // this.outDebug("p2Gcj02 = ", p2Gcj02);
    let p2Bd09 = DataUtil.gcj02tobd09(parseFloat(p2Gcj02[0]), parseFloat(p2Gcj02[1]));
    // this.outDebug("p2Bd09 = ", p2Bd09);
    let p1 = new BMap.Point(p1Bd09[0], p1Bd09[1]);//起点
    let p2 = new BMap.Point(p2Bd09[0], p2Bd09[1]);//终点


    ins_m.initCalData();
    ins_m.showMsg("开始进行路线规划，请稍后......");
    baiduDriving.search(p1, p2);
    ins_m.initGpsBasicData();
}

//初始化基本数据，如果没有，则从控件中补全
ins_m.initGpsBasicData = function () {
    let that = this;
    let basicData = this.data.gpsBasicData;
    if(DataUtil.isDefined(basicData.plateNo)){
        basicData.plateNo = $("#ins_m_cal_plateNo").val();
    }
    if(DataUtil.isDefined(basicData.simNo)){
        basicData.simNo = $("#ins_m_cal_simNo").val();
    }
    if(DataUtil.isDefined(basicData.mileage)){
        basicData.mileage = 0;
    }
    //获取车牌颜色
    let temp = {};
    temp.plateNo = DataUtil.isDefined(ins_m.data.gpsBasicData.plateNo) ? "" : ins_m.data.gpsBasicData.plateNo;
    if (temp.plateNo != "") {
        temp.queryId = "insertAndTrans.selectPlateColorbyNo";
        let url = globalConfig.webPath + "/basicSlctAction/basicSelectData.action";
        Utility.getAjaxData(url, JSON.stringify(temp), function (data) {
            // ins_m.outDebug("接收到查询车牌颜色数据！" , data);
            if (data.success) {
                if (data.data && data.data.length > 0) {
                    that.data.plateColor = data.data[0].plateColor;
                    $("#ins_m_cal_plateColor").val(that.data.plateColor);
                    // that.outDebug("plateColor:" + that.data.plateColor);
                }
            } else {
                ins_m.showMsg(data.message);
            }
        });
    }
    
}


//百度驾驶路径规划完成后的回调方法
ins_m.baiduDrivingCompleteCallback = function(result){
    ins_m.showMsg("轨迹规划完成!");
    let coutData = baiduDriving.getResults().getPlan(0).getRoute(0);
    let pts = baiduDriving.getResults().getPlan(0).getRoute(0).getPath();
    let list = [];
    if (pts.length > 0) {
        $.each(pts, function (n, item) {
            let lng = item.lng;
            let lat = item.lat;
            let gcj02Xy = DataUtil.bd09togcj02(lng, lat);
            let wgs84Xy = DataUtil.gcj02towgs84(gcj02Xy[0], gcj02Xy[1]);
            let obj = {};
            obj.longitude = wgs84Xy[0].toFixed(6);
            obj.latitude = wgs84Xy[1].toFixed(6);
            list.push(obj);
        })
    }
    ins_m.data.pList = list;
    ins_m.data.miles = 0;
    if(!DataUtil.isDefined(coutData)){
        ins_m.data.miles = coutData.ag;
    }
    // ins_m.outDebug("路径相关信息为：", coutData);
    // ins_m.outDebug("两点之间的距离为：" + ins_m.data.miles);
    // ins_m.outDebug("系统路径计算完成,数据为：", list);

    $("#ins_m_calData_tab").datagrid("loadData",list);

    //计算基本数据：
    // ins_m.calbasicDataInfo(list,ins_m.data.miles);

    ins_m.initBasicDataTojsObj(list,ins_m.data.miles);//获取基本信息进行封装
    
}


//获取基本信息进行封装,封装前首先清除数据缓存-------------------------------------------------------------------------------------获取基本信息
ins_m.initBasicDataTojsObj = function(list,mile){
    try {
        
        //清空缓存
        InsertGps.msgDivId = "ins_m_msg_div";
        InsertGps.initDataCache();

        //起点数据
        let start = {};
        let p1Wgs84 = DataUtil.gcj02towgs84(parseFloat($("#ins_m_point1_lng_input").val()), parseFloat($("#ins_m_point1_lat_input").val()));
        start.longitude = p1Wgs84[0];
        start.latitude = p1Wgs84[1];
        start.time = $("#ins_m_cal_startDate").datetimebox("getValue");
        InsertGps.cache.start = start;

        //终点数据
        let end = {};

        let p2Wgs84 = DataUtil.gcj02towgs84(parseFloat($("#ins_m_point2_lng_input").val()), parseFloat($("#ins_m_point2_lat_input").val()));
        end.longitude = p2Wgs84[0];
        end.latitude = p2Wgs84[1];
        end.time = $("#ins_m_cal_endDate").datetimebox("getValue");
        InsertGps.cache.end = end;

        //路径数据
        InsertGps.cache.routList = list;

        // this.outDebug("basicData:" , this.data.gpsBasicData);

        //状态数据
        let statusData = {};
        statusData.totalMile = mile;
        statusData.plateNo = $("#ins_m_cal_plateNo").val();
        statusData.simNo = $("#ins_m_cal_simNo").val();
        statusData.plateColor = $("#ins_m_cal_plateColor").val();
        if (!DataUtil.isDefined(this.data.gpsBasicData.mileage)) {
            statusData.mileage = this.data.gpsBasicData.mileage;
        } else {
            statusData.mileage = 0;
        }
        InsertGps.cache.statusData = statusData;
        statusData.createDate = $("#ins_m_cal_createDate").datetimebox("getValue");
        statusData.altitude = $("#ins_m_cal_altitude").val();
        //直线偏移量，用于计算里程数据
        if (!DataUtil.isDefined(this.data.gpsBasicData.distance)) {
            statusData.distanceMile = this.data.gpsBasicData.distance;
        } else {
            statusData.distanceMile = statusData.totalMile;
        }

        // this.outDebug("statusData:" , InsertGps.cache.statusData);
        //设置数据
        if (!isNaN(parseInt($("#ins_m_cal_maxSpeed").val()))) {
            InsertGps.config.maxSpeed = parseInt($("#ins_m_cal_maxSpeed").val());
        }
        InsertGps.config.noDriveFlg = $("#ins_m_noDrive2to5").is(":checked");

        InsertGps.checkInitDatas();
        InsertGps.outDebug("校验结果：" + InsertGps.getAllMsg());
        InsertGps.outDebug("数据：", InsertGps);

        InsertGps.getGpsListData();//-----------------------------------------------------------------------------开始获取列表数据！
        $("#ins_m_calData_tab").datagrid("loadData", InsertGps.cache.gpsList);//载入计算数据
        //载入平均速度
        $("#ins_m_cal_speed").val(InsertGps.calCache.speed.toFixed(1));
        //载入总距离
        $("#ins_m_cal_miles").html((InsertGps.cache.statusData.totalMile / 1000).toFixed(1));
        //载入耗时
        $("#ins_m_cal_time").html((InsertGps.calCache.timeValue / 60).toFixed(1));

        let str = InsertGps.cache.errorMsg + InsertGps.cache.waringMsg;
        if (str == "") {
            if (ins_m.flg.autoInsertFlg == true) {
                ins_m.showMsg("计算完成，开始自动插入........");
                $(document).oneTime('2s', 'autoInsertData85030211111', function () {
                    ins_m.insertGpsBeforeCheck();
                });
            } else {
                ins_m.showMsg("计算完成！");
            }
        } else {
            ins_m.showMsg(str);
        }

    } catch (error) {
        console.error("获取轨迹基本信息并计算失败：" + error);
    }
}


//计算基本的数据信息并进行显示--------------------------------------有自动计算---------------分时段补轨迹
ins_m.calbasicDataInfo = function(list,miles){
    let msg = "";
    //计算平均速度
    $("#ins_m_cal_speed").val(0);
    $("#ins_m_cal_miles").html("");
    $("#ins_m_cal_time").html("");
    let cal_startDate = $("#ins_m_cal_startDate").datetimebox("getValue");
    let cal_endDate = $("#ins_m_cal_endDate").datetimebox("getValue");
    if(cal_startDate != "" && cal_endDate != ""){
        //总里程
        let milesStr = miles/1000;
        milesStr = milesStr.toFixed(1);
        $("#ins_m_cal_miles").html(milesStr);

        //平均速度
        let start = new Date(cal_startDate).getTime();
        let end = new Date(cal_endDate).getTime();
        let res = (end - start) / 1000;
        ins_m.data.times = res;
        // ins_m.outDebug("开始时间为：" + start + " , 结束时间为：" + end + " , 差值为：" + res);
        if(res > 0 ){
            //显示时间间隔
            $("#ins_m_cal_time").html(parseFloat(res/60).toFixed(1));
            //速度
            let speed = miles / res * 3.6;
            speed = speed.toFixed(1);
            $("#ins_m_cal_speed").val(speed); 

            ///////////////////////////////////增加车速校验
            if(speed > ins_m.flg.autoInsertSpeed){
                msg += "平均车速超过 " + ins_m.flg.autoInsertSpeed + " ,如果需要插入，请手动进行!"
            }

        }else{
            msg += "车机时间结束时间小于开始时间，无法计算平均速度!"
        }
    }else{
        msg += "车机时间不完整，无法计算平均速度!"
    }

    //校验时间合法性
    msg += ins_m.checkAutoInsertParam();

    //自动计算轨迹数据
    if (msg == "") {
        ////////////////////////////////////////////自动补数据------->开始计算数据
        if (ins_m.flg.autoInsertFlg == true) {
            ins_m.showMsg("开始自动计算........");
            //如果是分时间段插入数据，则在停车时间段，速度为0
            if(ins_m.quantumData.quantumList.length > 0){
                let index = ins_m.quantumData.insertIndex;
                if(ins_m.quantumData.quantumList[index].speed == 0){
                    $("#ins_m_cal_speed").val("0");
                }
            }
            $(document).oneTime('2s','autoCalRote85030211111',function(){
                ins_m.fomratCaledRoutDatas();
            });
        }
    }else{
        ins_m.showMsg(msg);
        ins_m.flg.autoInsertFlg = false;
    }

    //超过4小时
    if (msg.indexOf("起止时间大于4小时，预防疲劳驾驶") > -1){
        $.messager.confirm("询问","是否分时段多次补轨迹？",function(res){
            if(res){
                ins_m.outDebug("开始进行截取计算!");
                ins_m.getQuantumList();
            }
        });
    }
}



/////////////////////////////////////////////////////////////////分时段补轨迹相关
/////////////////////////////////////////////////////////////////
//获取时间段数据
ins_m.getQuantumList = function(){
    let msg = "";
    ins_m.quantumData.quantumList = [];
    let startTime = new Date($("#ins_m_cal_startDate").datetimebox("getValue"));
    let start = startTime.getTime();
    let endTime = new Date($("#ins_m_cal_endDate").datetimebox("getValue"));
    let end = endTime.getTime();
    ins_m.outDebug("开始时间：" , Utility.dateToString(startTime) + " , start : " + start);
    ins_m.outDebug("结束时间：" , Utility.dateToString(endTime) + " , end : " + end);
    
    this.getQuantumTimes(start,end);//获取时间段数据

    msg += this.checkQuantumSpeed();//校验加入停车时段后平均速度是否合法

    if(msg == ""){
        //获取坐标点
        msg += this.getQuantumPoints();
    }

    ins_m.outDebug("时间段数据：" , this.quantumData.quantumList);
    if(msg == ""){
        //可以分段补,
        ins_m.quantumData.insertIndex = 0;//开始第0个插入
        ins_m.insertOneQuantumData();
    }else{
        ins_m.showMsg(msg);
    }

   
    return msg;
}

//截取时间数据
ins_m.getQuantumTimes = function(start,end){
    let msg = "";
    let speedValue = 1000 * 60 * 235 ; //235分钟，3小时55分
    let zeroValue = 1000 * 60 * 23 ; //23分钟，停车时间
    let quantumList = [];
    for(let i=0 ; i<30 ; i++){
        let time = 0;
        let speed = -2;
        if(quantumList.length == 0){
            //第一个
            time = start;
            speed = -1;
        }else{
            //非第一个
            let temp = quantumList[quantumList.length - 1];
            if (!DataUtil.isDefined(temp)) {
                //其余的
                if (temp.speed == 0) {
                    //停车点,添加23分钟后的时间
                    time = temp.time + zeroValue;
                    speed = -1;
                } else {
                    //行驶点
                    time = temp.time + speedValue;
                    speed = 0;
                }
            }
        }
        let flg = false;
        if(time > end){
            time = end;
            flg = true;
        }
        let obj = {
            time:time,
            speed:speed,
            lng:-1,
            lat:-1,
            pIndex:-1,
            timeStr:Utility.dateToString(new Date(time)),
        };
        quantumList.push(obj);
        if(flg == true){
            
            break;
        }
    }
    ins_m.quantumData.quantumList = quantumList; ///////////前面的值修改为需要保存的时间段对象
    return msg ;
}

//校验平均速度是否合法
ins_m.checkQuantumSpeed = function () {

    let msg = "";
    let miles = parseFloat($("#ins_m_cal_miles").html());//后面的值改为规划路径总公里数
    let quantumList = ins_m.quantumData.quantumList; //后面的值改为时间段列表对象
    let value = 0;
    //获取总时间
    for (let i = 0; i < quantumList.length; i++) {
        if (i + 1 < quantumList.length) {
            let temp = quantumList[i];
            let temp2 = quantumList[i + 1];
            if (!DataUtil.isDefined(temp) && !DataUtil.isDefined(temp2)) {
                //只计算有速度的
                if (temp.speed == -1) {
                    value += temp2.time - temp.time;
                }
            }

        }
    }
    if (value > 0) {

        //输出///////////////////////////////////根据情况显示
        value = value / (1000 * 60 * 60);
        let speed = miles / value;
        let str = "";
        if (speed > 100) {
            str = "车速不合法！";
            msg += str;
        } else {
            str = "车速合法！";
        }
        ins_m.outDebug("总公里数：" + miles + " ， 用时：" + value + " 小时，平均车速为：" + speed + " , " + str);

        //计算截取段数
        ins_m.quantumData.pointQuantumValue = parseFloat(value * 60 / 235).toFixed(2);///////////////////前面的值改为需要保存截取端数的对象
        ins_m.outDebug("坐标点需要截取的段数为：" + ins_m.quantumData.pointQuantumValue);
    } else {
        msg += "计算车辆行驶时间失败！";
    }
    return msg;
}

//获取时间段坐标点
ins_m.getQuantumPoints = function(){
    let msg = "";
    let pointQuantumValue = parseFloat(ins_m.quantumData.pointQuantumValue);//后面的值改为截取的段数就行
    let list = ins_m.data.pList;//后面的值改为规划好的坐标点
    let quantumList = ins_m.quantumData.quantumList; ////后面的值改为时间段数据
    if( pointQuantumValue > 0 && list.length > 0){
        let value = parseInt(list.length / pointQuantumValue );
        if(value > 0){
            ins_m.outDebug("每段截取的数量为：" + value);
            //开始截取
            let flg = false;//
            for(let i= 0 ; i< pointQuantumValue + 1 ; i++){
                let index = i*value -1;
                if(index < 0){
                    index = 0;
                }else if(index > list.length - 1){
                    index = list.length - 1;
                }
                ins_m.outDebug("开始截取第" + (i+1) +  "段 , 索引为：" + index);

                //计算时间段索引值
                //第一个点停车点
                let qIndex = i*2-1;
                if(qIndex > -1 && qIndex < quantumList.length){
                    quantumList[qIndex].lng = list[index].longitude;//第一个点的经度为索引点的经度
                    quantumList[qIndex].lat = list[index].latitude;
                    quantumList[qIndex].pIndex = index ;
                }
                //第二个点，开始行驶点
                let qIndex2 = i*2;
                if(qIndex2 > -1 && qIndex2 < quantumList.length){
                    quantumList[qIndex2].lng = list[index].longitude;//第一个点的经度为索引点的经度
                    quantumList[qIndex2].lat = list[index].latitude;
                    quantumList[qIndex2].pIndex = index ;
                }
            }
        }else{
            msg += "截取数据失败：每段坐标数量小于0";
        }
    }else{
        msg += "坐标截取值或者坐标数据不合法！";
    }

    return msg;
}

//插入单个事件单的数据
ins_m.insertOneQuantumData = function(){
    let msg = "";
    let index = ins_m.quantumData.insertIndex;
    let list = ins_m.quantumData.quantumList;
    if (index > -1 && index < list.length - 1) {
        ins_m.outDebug("开始插入第 " + (index +1) + " 个时间段的数据...........");
        try {
            let lng1 = isNaN(parseFloat(list[index].lng)) ? 0 : parseFloat(list[index].lng);
            let lat1 = isNaN(parseFloat(list[index].lat)) ? 0 : parseFloat(list[index].lat);

            let lng2 = isNaN(parseFloat(list[index].lng+1)) ? 0 : parseFloat(list[index+1].lng);
            let lat2 = isNaN(parseFloat(list[index+1].lat)) ? 0 : parseFloat(list[index+1].lat);

            if (lng1 > 0 && lat1 > 0 && lng2 > 0 && lat2 > 0) {
                let p1Gcj02 = DataUtil.wgs84togcj02(lng1, lat1);
                let p2Gcj02 = DataUtil.wgs84togcj02(lng2, lat2);

                $("#ins_m_point1_lng_input").val(p1Gcj02[0].toFixed(6));
                $("#ins_m_point1_lat_input").val(p1Gcj02[1].toFixed(6));

                $("#ins_m_point2_lng_input").val(p2Gcj02[0].toFixed(6));
                $("#ins_m_point2_lat_input").val(p2Gcj02[1].toFixed(6));

                $("#ins_m_cal_startDate").datetimebox("setValue", (DataUtil.isDefined(list[index].timeStr) ? "" : list[index].timeStr));
                $("#ins_m_cal_endDate").datetimebox("setValue", (DataUtil.isDefined(list[index+1].timeStr) ? "" : list[index+1].timeStr));
            } else {
                msg += "获取经纬度参数失败，无法自动插入数据!" ;
            }



        } catch (error) {
            msg += "插入自动补数据所需参数失败：" + error;
        }
    }else{
        if(index == list.length -1){
            msg += "最后一个数据段已完成！";
        }else{
            msg += "获取时间段索引失败！";
        }
    }

    //正确的开始计算
    if(msg == ""){
        //设置自动插入标记
        ins_m.flg.autoInsertFlg = true;//设置自动插入标记
        ins_m.initAutoInsertFlg();
        ins_m.getBaiduRoute();//开始规划路线
    }else{
        ins_m.showMsg(msg);
    }

}



/////////////////////////////////////////////////////////////////轨迹数据计算


//轨迹数据计算-------------------------------------------------------有自动插入
ins_m.fomratCaledRoutDatas = function(){
    let that = this;
    if(this.flg.calFlg == 0){
        this.flg.calFlg = 1;//设置计算标记
        let that = this;
        ins_m.getRouteCalParam();
        if(ins_m.data.calParam.message == ""){
            //开始计算
            ins_m.outDebug("数据合法，开始计算......");
            ins_m.showMsg("数据合法，开始计算......");
            ins_m.outDebug(ins_m.data.calParam);
            let param = ins_m.data.calParam;
            let msg = "";
            if (param.points > param.nums) {
                //轨迹点数量大于取点数量，正常算法取点，
                msg += ins_m.getRouteNomal();
            } else {
                //轨迹点数量小于取点数量，需要静止点
                msg += ins_m.getRouteUnNomal();
            }

            //计算完成，校验数据
            msg += ins_m.checkAutoInsertParam();//校验时间合法性
            msg += ins_m.checkSpeedValue();//校验车速合法性
            msg += ins_m.checkTooFastSpeed();//校验是否超速位移

            if(msg != ""){
                that.showMsg(msg);
                ins_m.flg.autoInsertFlg = false;/////自动补传标记设置为false
            }else{
                that.showMsg("gps轨迹数据计算完成！")
             
                ///////////////////////////////////////////////////////////////////////////自动补数据，插入数据
                if(that.flg.autoInsertFlg == true){
                    ins_m.showMsg("开始自动插入........");
                    $(document).oneTime('2s','autoInsertData85030211111',function(){
                        ins_m.insertGpsBeforeCheck();
                    });
                }
            }
    
        }else{
            ins_m.outDebug(ins_m.data.calParam.message);
            ins_m.showMsg(ins_m.data.calParam.message);
        }
        this.flg.calFlg = 0;//重置计算标记
    }else{
        this.outDebug("请不要重复点击计算按钮！")
    }

    
}

//获取轨迹计算参数
ins_m.getRouteCalParam = function(){
    let param = {message:""};
    //校验基本数据
    param.message += this.data.pList.length <= 0 ? "轨迹点数据为空！" : "";
    param.points = this.data.pList.length <= 0 ? 0 : this.data.pList.length;
    param.message += this.data.miles <= 0 ? "轨迹距离为0！" : "";
    param.message += this.data.times <= 0 ? "时间间隔非法！" : "";

    if(DataUtil.isDefined(ins_m.data.gpsBasicData)){
        msg += "基本数据为空，无法获取车牌号和总里程等数据！"
    }

    let nums = parseInt(this.data.times / this.data.offset.time) - 1;
    param.nums =  isNaN(nums) ? 0 : nums;
    if(isNaN(nums)){
        param.message += "计算轨迹点数量失败！"
    }else if(nums <= 1){
        param.message += "需要计算的轨迹点仅有一个，不建议计算！";
    }
    //车牌号
    let plateNo = $("#ins_m_cal_plateNo").val();
    if(plateNo == ""){
        plateNo = this.data.gpsBasicData.plateNo;
    }
    if(DataUtil.isDefined(plateNo) ||  plateNo == ""){
        param.message +="车牌号码数据获取失败！";
    }else{
        param.plateNo = plateNo;
    }

    //simNo
    let simNo = $("#ins_m_cal_simNo").val();
    if(simNo == ""){
        simNo = this.data.gpsBasicData.simNo;
    }
    if(DataUtil.isDefined(simNo) || simNo == ""){
        param.message += "simNo获取失败！";
    }else{
        param.simNo = simNo;
    }

    //plateColor
    let plateColor = isNaN(parseInt($("#ins_m_cal_plateColor").val())) ? -1 : parseInt($("#ins_m_cal_plateColor").val());
    if(plateColor == -1){
        plateColor = this.data.plateColor;
    }
    if(plateColor == -1){
        param.message += "车牌颜色获取失败！";
    }else{
        param.plateColor = plateColor;
    }
    
    
    
    //里程偏移量
    param.milesOft = 0;
    if(param.nums > 0){
        param.milesOft = ins_m.data.miles / (param.nums * 1000);
    }

    //校验参数数据
    let createDate = $("#ins_m_cal_createDate").datetimebox("getValue");
    if(createDate != ""){
        param.createDate = createDate;
        param.createDateValue = new Date(createDate).getTime();
        // this.outDebug("当前时间：" + new Date().getTime() + " , 接收时间：" + param.createDateValue);
    }else{
        param.message += "接收时间非法！";
    }

    //车机开始时间
    let startDate = $("#ins_m_cal_startDate").datetimebox("getValue");
    if(startDate != ""){
        param.startDate = startDate;
        param.startDateValue = new Date(startDate).getTime();
        // this.outDebug("车机开始时间：" + param.startDateValue);
    }else{
        param.message += "车机开始时间非法!";
    }

    //车机结束时间
    let endDate = $("#ins_m_cal_endDate").datetimebox("getValue");
    if(endDate != ""){
        param.endDate = endDate;
        // this.outDebug("车机结束时间：" + param.endDate);
    }else{
        param.message += "车机结束时间非法！";
    }

    //平均速度
    let speed = parseFloat($("#ins_m_cal_speed").val());
    if(!isNaN(speed)){
        param.speed = speed.toFixed(1);
    }else{
        param.message += "车辆平均速度不合法！";
    }

    //最高限速
    let maxSpeed = parseFloat($("#ins_m_cal_maxSpeed").val());
    if(!isNaN(maxSpeed)){
        param.maxSpeed = maxSpeed.toFixed(1);
    }else{
        param.message += "最高限速不合法！";
    }

    //总体方向
    let direction = parseInt($("#ins_m_cal_direction").val());
    if(!isNaN(direction)){
        param.direction = direction;
    }else{
        param.message += "总体方向不合法";
    }

    //平均海拔
    let altitude = parseInt($("#ins_m_cal_altitude").val());
    if(!isNaN(altitude)){
        param.altitude = altitude;
    }else{
        param.message += "平均海拔不合法！";
    }

    this.data.calParam = param;
}


//校验是否超速位移
ins_m.checkTooFastSpeed = function(){
    let that = this;
    let msg = "";
    try {
        let list = ins_m.data.resList;
        this.outDebug("筛选过后的轨迹数据为：" , list);
        let num = list.length;
        if(num > 0){
            //获取起点和终点坐标经纬度
            let obj = this.getStartAndEndPointData();
            if(obj.message == ""){
                //起点终点数据合法,开始校验数据
                that.outDebug("起点和终点数据为：" , obj);
                let str = "";
                that.data.speedMsg = "";
                for(let i=0 ; i<num ; i++){
                    //校验当前点和前一点
                    if(i == 0){//校验和起点
                        str = that.isTooFastPoint(obj.start,list[i],i,0);
                        if(str  != ""){
                            msg += "存在漂移点，序号：" + (i+1) + " , 原因：和起点比较，" + str;
                            break;
                        }
                    }else{//校验和前一点
                        str = that.isTooFastPoint(list[i-1],list[i],i,0);
                        if( str != ""){
                            msg += "存在漂移点，序号：" + (i+1)+ " , 原因：和前一点比较，" + str;
                            break;
                        }
                    }
                    //校验当前点和后一点
                    if(i == num-1){//校验当前点和终点
                        str = that.isTooFastPoint(list[i],obj.end,i,1);
                        if(str != ""){
                            msg += "存在漂移点，序号：" + (i+1)+ " , 原因：和终点比较，" + str;
                            break;
                        }
                    }
                }

                that.outDebug("漂移校验结果：" , that.data.speedMsg);
    
            }else{
                msg += obj.message;
            }
        }else{
            msg += "当前无需要更新的GPS轨迹数据！";
        }
        
    } catch (error) {
        msg += "校验插入轨迹点是否超速位移失败:" + error;
    }
    return msg;
}

//获取起点终点数据
ins_m.getStartAndEndPointData = function(){
    let obj = {
        start:{sendTime:"",latitude:0,longitude:0},
        end:{sendTime:"",latitude:0,longitude:0},
        message:"",
    };
    //获取起点经纬度
    let p1lng = parseFloat($("#ins_m_point1_lng_input").val());
    if (!isNaN(p1lng)) {
        obj.start.longitude = p1lng.toFixed(6);
    } else {
        obj.message += "起点经度不合法！";
    }
    let p1lat = parseFloat($("#ins_m_point1_lat_input").val());
    if (!isNaN(p1lat)) {
        obj.start.latitude = p1lat.toFixed(6);
    } else {
        obj.message += "起点纬度不合法！";
    }

    //获取终点经纬度
    let p2lng = parseFloat($("#ins_m_point2_lng_input").val());
    if (!isNaN(p2lng)) {
        obj.end.longitude = p2lng.toFixed(6);
    } else {
        obj.message += "终点经度不合法！";
    }
    let p2lat = parseFloat($("#ins_m_point2_lat_input").val());
    if (!isNaN(p2lat)) {
        obj.end.latitude = p2lat.toFixed(6);
    } else {
        obj.message += "终点纬度不合法！";
    }

    //获取起点时间
    let now = new Date().getTime();
    let start = new Date($("#ins_m_cal_startDate").datetimebox("getValue")).getTime();
    if(now != start){
        obj.start.sendTime = $("#ins_m_cal_startDate").datetimebox("getValue");
    }else{
        obj.message += "获取车机起始时间失败！";
    }

    //获取终点时间
    let end = new Date($("#ins_m_cal_endDate").datetimebox("getValue")).getTime();
    if(now != end){
        obj.end.sendTime = $("#ins_m_cal_endDate").datetimebox("getValue");
    }else{
        obj.message += "获取车机结束时间失败！";
    }

    return obj;
}

//校验两点之间的速度是否超过160
ins_m.isTooFastPoint = function(point1,point2,index,flg){
    let msg = ""
    let distance = -1;
    distance = this.algorithm(point1.longitude,point1.latitude,point2.longitude,point2.latitude);
    if(isNaN(distance) || distance < 0){
        msg += "获取两点之间的距离失败！";
    }
    let timeValue = -1;
    try {
        timeValue = Math.abs((new Date(point1.sendTime).getTime() - new Date(point2.sendTime).getTime())/1000);
        if(timeValue <= 0){
            msg += "获取时间差值失败！";
        }
    } catch (error) {
        msg += "获取时间差值失败！";
    }
    
    let speed = distance * 3.6 / timeValue;
    this.outDebug("speed = " + speed);
    if(speed >= this.data.tooFastValue){
        msg += "漂移点,车速为：" + speed.toFixed(1) + "(km/h) ,距离：" + distance.toFixed(1) + "米 ， 时间差为：" + timeValue + " 秒！";
    }

    let str = "";
    if(flg == 0){
        str = "之前点";
    }else{
        str = "之后点";
    }
    this.data.speedMsg += "序号：" +  (index + 1) + " , 和" + str + " 计算，车速为：" + speed.toFixed(2) + "(km/h) , 距离：" + distance.toFixed(1) + "米 ， 时间差为：" + timeValue + " 秒-----------------"

    return msg ;
}

//计算两点间的距离，单位为米
ins_m.algorithm = function(longitude1,latitude1,longitude2,latitude2){
    let s = 0.0;
    // this.outDebug("开始进行两点间距离计算..." );
    try {
        // this.outDebug("开始进行两点间距离计算2..." );
        let lat1 = ins_m.rad(latitude1);//纬度
        // this.outDebug("lat1 = " + lat1);
        let lat2 = ins_m.rad(latitude2);
        // this.outDebug("lat2 = " + lat2);
        let a = lat1 - lat2;
        // this.outDebug("a = " + a);
        let b = this.rad(longitude1) - this.rad(longitude2);
        // this.outDebug(" b = " + b);
        s = 2*Math.asin(Math.sqrt(Math.pow(Math.sin(a/2),2) + Math.cos(lat1)*Math.cos(lat2) * Math.pow(Math.sin(b/2),2)));
        // this.outDebug("s = " + s);
        s = s * 6378137.0;//弧长乘地球半径（半径为米)
        // this.outDebug("乘地球半径后的结果：" + s);
        s = Math.round(s * 10000.0)/10000.0;
    } catch (error) {
        // that.outDebug("计算两点间距离失败：" + error);
        s = -1;
    }
    return s;
}

//角度转弧度
ins_m.rad = function(value){
    try {
        return (value * Math.PI / 180);
    } catch (error) {
        // this.outDebug("角度转弧度失败：" + error);
        return NaN;
    }
}
/////////////////////正常算法取点
/*
算法：
整个规划路线点数量：point
需要的轨迹点数量：nums
当points > nums ，则整个路线分为三段，
    前段，每若干个轨迹点取一个点， firstNum = (points - nums)/(numsOft-1) 然后取整数部分
    后端，每个点都作为一个点，  lastNum = nums - firstNum - firstOftNum
    中段，作为前端的偏移，不足若干个，但是大于1个，firstOftNum 为0或者1
若干个点的计算方法：points / nums ,向上取整，变量名：numsOft
*/

//轨迹点数量大于取点数量：points > nums ，正常取点
ins_m.getRouteNomal = function(){
    let msg = "";
    let param = ins_m.data.calParam;
    let pList = this.data.pList;
    if(pList.length <= 0){
        msg += "待截取轨迹点数据为空数据，无法截取计算！";
    }
    this.outDebug( "basicData:" ,  ins_m.data.gpsBasicData);
    if(DataUtil.isDefined(ins_m.data.gpsBasicData)){
        msg += "基本数据为空，无法获取车牌号和总里程等数据！"
    }
    //取点间隔
    let numsOft = parseFloat(param.points / param.nums);
    if(!isNaN(numsOft)){
        numsOft = Math.ceil(numsOft);
        if(numsOft > 1){

            //计算相关数据
            let indexOft = Math.ceil(numsOft /2);
            let firstNum = parseFloat((param.points - param.nums) / (numsOft -1));
            let firstOftNum = 0;
            let lastNum = 0;
            let length = pList.length;
            if(!isNaN(firstNum)){
                if(firstNum - Math.floor(firstNum) > 0){
                    firstOftNum = 1;
                }
                firstNum = Math.floor(firstNum);
                lastNum = param.nums - firstNum - firstOftNum;
                if(lastNum < 0){
                    msg += "计算后端轨迹点数量失败！";
                } 
            }else{
                msg += "计算前段轨迹点数量失败！"
            }

            if(indexOft < 0 || indexOft >= numsOft){
                msg += "截取偏移量计算错误！"
            }

            //开始获取轨迹点
            if(msg == ""){
                // this.outDebug("numsOft = " + numsOft + "  , indexOft = " + indexOft + " , firstNum = " + firstNum + " , firstOftNum = " + firstOftNum + " , lastNum = " + lastNum);
                let resList = [];
                let totalIndex = 0;//定义索引，用于计算时间
                //获取前段数据
                if(firstNum > 0){
                    for(let i=0 ; i< firstNum ; i++){
                        let index = i * numsOft + indexOft;//索引
                        if(index < length){
                            totalIndex = totalIndex + 1;
                            let obj =ins_m.getGpsData(index,totalIndex);
                            if(obj.message == ""){
                                resList.push(obj);
                            }else{
                                msg += obj.message;
                            }
                        }else{
                            msg +="第" + (i+1) + "个前段轨迹点获取失败，超出索引！"
                        }
                    }
                }
                //获取中段数据
                if(firstOftNum > 0){
                    let index = firstNum * numsOft;
                    if(index < length){
                        totalIndex = totalIndex + 1;
                        let obj = ins_m.getGpsData(index,totalIndex);
                        if (obj.message == "") {
                            resList.push(obj);
                        } else {
                            msg += obj.message;
                        }
                    }else{
                        msg += "获取中段轨迹点失败，超出索引!"
                    }
                }
                //获取后段索引
                if(lastNum > 0){
                    let temp = length - lastNum;
                    if(temp >= 0){
                        for(let i=temp ; i<length ; i++){
                            totalIndex = totalIndex + 1;
                            let obj = ins_m.getGpsData(i,totalIndex);
                            if(obj.message == ""){
                                resList.push(obj);
                            }else{
                                msg += obj.message;
                            }
                        }
                    }else{
                        msg += "获取后段轨迹点失败，超出索引！"
                    }
                }
                //保存
                if(msg == ""){
                    this.data.resList = resList;
                    $("#ins_m_calData_tab").datagrid("loadData",resList);
                    this.outDebug("resList : " , resList);
                }
            }
            
        }else{
            msg += "取点间隔参数错误，请重试！"
        }
    }else{
        msg += "获取取点间隔数据失败，请重试！"
    }

    return msg;
}


/////////////////////////UnNomalCal


/*
算法：
整个规划路线点数量：point
需要的轨迹点数量：nums
当points <= nums ，则整个路线分为两段
    前段：停车点，整个前段的停车点都是一个经纬度，数量firstNum = nums - points + 1 ,经纬度点在pList列表中的第一个点
    后段：正常行驶点，每个点都是一个取点，lastNum = points - 1 ,经纬度数据从pList 表中第二个点开始，到最后一个
*/

//轨迹点数量小于取点数量：points < nums ,含停车取点
ins_m.getRouteUnNomal = function(){
    let msg = "";
    let param = ins_m.data.calParam;
    let pList = this.data.pList;
    if(pList.length <= 0){
        msg += "待截取轨迹点数据为空数据，无法截取计算！";
    }
    this.outDebug( "basicData:" ,  ins_m.data.gpsBasicData);
    if(DataUtil.isDefined(ins_m.data.gpsBasicData)){
        msg += "基本数据为空，无法获取车牌号和总里程等数据！"
    }

    //开始计算截取
    let firstNum = param.nums - param.points + 1;
    let lastNum = param.points -1;
    if(firstNum > 0 && lastNum > 0){
        let resList = [];
        let totalIndex = 0;
        let length = pList.length;
        //前段数据
        for(let i=0 ; i<firstNum ; i++){
            totalIndex = totalIndex + 1;
            let obj = ins_m.getZeroGpsData(totalIndex);
            if (obj.message == "") {
                resList.push(obj);
            } else {
                msg += obj.message;
            }
        }

        //后段数据
        for(let j=0 ; j<lastNum ; j++){
            let index = j + 1;
            if(index < length){
                totalIndex = totalIndex + 1;
                let obj = ins_m.getGpsData(index,totalIndex);
                if (obj.message == "") {
                    resList.push(obj);
                } else {
                    msg += obj.message;
                }
            }else{
                msg += "获取后段轨迹点错误，超出索引！";
            }
        }

        if (msg == "") {
            ins_m.data.resList = resList;
            $("#ins_m_calData_tab").datagrid("loadData", resList);
            this.outDebug("resList : ", resList);
        }
    }else{
        msg += "前后段轨迹点计算错误！";
    }

    return msg;
}


////////////////////////////////获取经过格式化的gps数据

//获取经过格式化的gps数据
ins_m.getGpsData = function(index,totalIndex){
    let obj = {message:""};
    let temp = this.data;
    let pList = temp.pList;
    if(index > 0 && index < pList.length){
        obj.index = totalIndex + 1;//序号
        obj.oldIndex = index + 1;//原数据索引
        obj.longitude = pList[index].longitude;//经度
        obj.latitude = pList[index].latitude;//纬度
        obj.plateNo = ins_m.data.calParam.plateNo;

        let randomValue =  Math.random();//随机数
        //速度,如果速度大于最高速，则为最高速向下随机减,如果速度为0，则速度直接为0
        let speed0 = parseFloat(temp.calParam.speed);
        let maxSpeed = parseFloat(temp.calParam.maxSpeed);
        let speed = 0;
        let recSpeed = 0;
        if(speed0 > 0){
            speed = speed0 + (randomValue - 0.3) * temp.offset.speedOft;
            if(speed > maxSpeed){
                speed = maxSpeed - randomValue ;
            }else if(speed <= 0){
                speed = speed0 * randomValue;
            }
            recSpeed = speed  + 1 + randomValue - 0.5;  
        }
        obj.speed = speed.toFixed(1);
        obj.recSpeed = recSpeed.toFixed(1);

        //方向
        let direction = parseInt(temp.calParam.direction) + (randomValue - 0.5) * temp.offset.directOft;
        direction = parseInt(direction);
        if(direction < 0){
            direction = direction + 360;
        }else if(direction >= 360){
            direction = direction - 360;
        }
        obj.direction = direction;

        //海拔
        let altitude = temp.calParam.altitude + randomValue * temp.offset.altitudeOft;
        altitude = parseInt(altitude);
        obj.altitude = altitude;

        //总里程
        if(!DataUtil.isDefined(temp.gpsBasicData.mileage)){
            let mileage = temp.calParam.milesOft * totalIndex + temp.gpsBasicData.mileage;
            obj.mileage = mileage.toFixed(1);
        }else{
            obj.message += "基本数据对象为空，无法计算总里程！"
        }

        //车机时间
        let sendTime = temp.calParam.startDateValue + 30000 * totalIndex + parseInt(temp.offset.timeOft * (randomValue - 0.5)) * 1000 ;
        sendTime = Utility.dateToString(new Date(sendTime));
        obj.sendTime = sendTime;

        //接收时间
        let createDate = temp.calParam.createDateValue - parseInt((temp.calParam.nums - totalIndex)/temp.offset.createDateNumsOft) * 1000;
        createDate = Utility.dateToString(new Date(createDate));
        obj.createDate = createDate;


    }else{
        obj.message += "第 " + (totalIndex + 1) + " 个gps数据获取失败:超出索引！"
    }
    return obj;
}

/*
获取停车点的gps数据，默认为选择轨迹点列表中的第一个轨迹作为停车点
    停车点数据：
    经纬度：轨迹列表第一个元素作为坐标经纬度
    车速：0
    方向：参数方向
    海拔：参数海拔
    总里程：参数总里程，不需要叠加
    车机时间：和正常取点一样的车机时间
    接收时间：和正常取点一样的接收时间

 */
ins_m.getZeroGpsData = function(totalIndex){
    let obj = {message:""};
    let temp = this.data;
    let pList = temp.pList;
    if(pList.length > 0 ){
        obj.index = totalIndex + 1;//序号
        obj.oldIndex = 0;//原数据索引
        obj.longitude = pList[0].longitude;//经度
        obj.latitude = pList[0].latitude;//纬度
        obj.plateNo = ins_m.data.calParam.plateNo;

        let randomValue =  Math.random();//随机数

        obj.speed = 0;//速度
        obj.recSpeed = 0;
        obj.direction = temp.calParam.direction;//方向
        obj.altitude = temp.calParam.altitude;//海拔
        if(!DataUtil.isDefined(temp.gpsBasicData.mileage)){
            obj.mileage = temp.gpsBasicData.mileage;
        }else{
            obj.message += "基本数据对象为空，无法获取总里程！"
        }

        //车机时间
        let sendTime = temp.calParam.startDateValue + 30000 * totalIndex + parseInt(temp.offset.timeOft * (randomValue - 0.5)) * 1000 ;
        sendTime = Utility.dateToString(new Date(sendTime));
        obj.sendTime = sendTime;

        //接收时间
        let createDate = temp.calParam.createDateValue - parseInt((temp.calParam.nums - totalIndex)/temp.offset.createDateNumsOft) * 1000;
        createDate = Utility.dateToString(new Date(createDate));
        obj.createDate = createDate;

    }else{
        obj.message += "第 " + (totalIndex + 1) + " 个停车点gps数据获取失败:轨迹点列表为空！"
    }

    return obj;
}



/////////////////////////////////////////////////////////////////datagrid显示格式化方法

//选择数据块中的操作格式化方法
ins_m.slct_formatOperation = function(value,rowData,rowIndex){
    let str = '';
    let lng = isNaN(parseFloat(rowData.longitude)) ? 0 : parseFloat(rowData.longitude);
    let lat = isNaN(parseFloat(rowData.latitude)) ? 0 : parseFloat(rowData.latitude);
    let altitude = isNaN(parseFloat(rowData.altitude)) ? 0 : parseFloat(rowData.altitude);
    let sendTime = DataUtil.isDefined(rowData.sendTime) ? "" : rowData.sendTime;
    // let lat = rowData.lat + '';
    // str += '<a href="javascript:ins_m.setStartPoint(&quot;' + lng + '&quot;,&quot;' + lat +'&quot; );">起点</a> &nbsp;&nbsp;';
    str += '<a href="javascript:ins_m.setStartPoint(' + lng + ',' + lat
        + ', &quot;' + sendTime + '&quot;,' + altitude + ',' + rowIndex + ');">起点</a> &nbsp;&nbsp;';
    str += '<a href="javascript:ins_m.setEndPoint(' + lng + ',' + lat
        + ' , &quot;' + sendTime + '&quot;);">终点</a>';
    return str;
}

//设置起点坐标
ins_m.setStartPoint = function(lng,lat,time,altitude,rowIndex){
    // this.outDebug("起点坐标为：经度 = " + lng + " ， 纬度 = " + lat);
    let p1Gcj02 = DataUtil.wgs84togcj02(lng, lat);
    // this.outDebug("p1Gcj02 = ", p1Gcj02);
    // let p1Bd09 = DataUtil.gcj02tobd09(parseFloat(p1Gcj02[0]), parseFloat(p1Gcj02[1]));
    $("#ins_m_point1_lng_input").val(p1Gcj02[0].toFixed(6));
    $("#ins_m_point1_lat_input").val(p1Gcj02[1].toFixed(6));
    $("#ins_m_cal_startDate").datetimebox("setValue",time);
    $("#ins_m_cal_altitude").val(altitude);
    ins_m.setGpsBasicData(rowIndex);

    //初始化onlyTrans起点相关数据
    ins_m.onlyTrans.cache.startDate = time;
}

//设置基本数据
ins_m.setGpsBasicData = function(rowIndex){
    // ins_m.outDebug("开始设置基本数据!");
    let rows = $("#ins_m_slctDatagrid_tab").datagrid("getRows");
    // ins_m.outDebug("rows:" , rows);
    if(rows && rows.length > 0){
        let rowData = rows[rowIndex];
        // ins_m.outDebug("rowData:" , rowData);
        if(!DataUtil.isDefined(rowData)){
            // ins_m.outDebug("获取到第 " + rowIndex + " 行的数据，数据为：" , rowData);
            ins_m.data.gpsBasicData = rowData;
            $("#ins_m_cal_plateNo").val(DataUtil.isDefined(rowData.plateNo) ? "" : rowData.plateNo);
            $("#ins_m_cal_simNo").val(DataUtil.isDefined(rowData.simNo) ? "" : rowData.simNo);

            //初始化onlyTrans起点相关数据
            ins_m.onlyTrans.cache.plateNo = DataUtil.isDefined(rowData.plateNo) ? "" : rowData.plateNo;
            ins_m.onlyTrans.cache.simNo = DataUtil.isDefined(rowData.simNo) ? "" : rowData.simNo;
        }
    }
}


//设置终点坐标
ins_m.setEndPoint = function(lng,lat,time){
    // this.outDebug("终点坐标为：经度 = " + lng + " ， 纬度 = " + lat);
    let p2Gcj02 = DataUtil.wgs84togcj02(lng, lat);
    // this.outDebug("p1Gcj02 = ", p1Gcj02);
    // let p2Bd09 = DataUtil.gcj02tobd09(parseFloat(p2Gcj02[0]), parseFloat(p2Gcj02[1]));
    $("#ins_m_point2_lng_input").val(p2Gcj02[0].toFixed(6));
    $("#ins_m_point2_lat_input").val(p2Gcj02[1].toFixed(6));
    $("#ins_m_cal_endDate").datetimebox("setValue",time);

    //初始化onlyTrans终点相关数据
    ins_m.onlyTrans.cache.endDate = time;
    ins_m.outDebug("onlyTrans 相关数据为：" , ins_m.onlyTrans.cache);
}



/////////////////////////////////////////////////////////////////插入gps补轨迹数据
//插入数据之前首先校验
ins_m.insertGpsBeforeCheck = function(){
    if(this.flg.validPointFlg == false){//无有效点，直接插入
        ins_m.insertNewGpsDatas();
    }else{//有有效点，询问插入
        $.messager.confirm('确认', "当前不连续轨迹数据时间段内包含有效数据点，是否继续插入？", function (res) {
            if(res){
                ins_m.insertNewGpsDatas();
            }
        });
    }
}

//插入gps补轨迹数据
ins_m.insertGpsDatas = function(){
    let that = this;
    let msg = "";
    let calParam = this.data.calParam;
    let resList = this.data.resList;
    if(DataUtil.isDefined(calParam) || resList.length <= 0){
        msg += "整合gps数据失败，请重试！"
    }else{
        //获取转发标记
        let param = {};
        msg += that.setTransValue(param);
        
        //开始请求
        if(msg == ""){
            //GPS数据
            param.plateNo = calParam.plateNo
            param.simNo = calParam.simNo;
            param.plateColor = calParam.plateColor;
            param.alarmState = 0;
            param.status = 790531;//车辆状态，Acc开（0），定位（1），车门枷锁（12），gps定位（18），北斗定位（19）
            param.gas = 0;
            param.valid = 1;//数据有效
            param.commandId = 0;
            param.gpsList = JSON.stringify(resList);//gps数据列表

            //用于记录日志信息的数据
            param.insertCreateDate = calParam.createDate;
            param.insertSatrtDate = calParam.startDate;
            param.insertEndDate = calParam.endDate;



            let url = globalConfig.webPath + "/insertAndTrans/insertGpsDatas.action";
            that.outDebug("需要插入的参数：",param);
            $("#ins_m_cal_insertGpsData").attr("disabled","disabled");
            that.showMsg("开始插入数据.......");
            Utility.getAjaxData(url,JSON.stringify(param),function(data){
                that.outDebug("接收到插入gps数据响应：", data);
                if(data.success){
                    let str = "";
                    if(DataUtil.isDefined(param.transFlg)){
                        str = "本次不允许809转发!";
                    }
                    str =  "  " + data.message + "插入的gps定位数据数量为：" +data.data + "条!" + str;
                    that.showMsg(str);
                    //开始更新状态
                    that.deleteOneDisData(str);
                }else{
                    that.showMsg("  " +data.message);
                }
                ins_m.flg.autoInsertFlg = false;

                //判断是否有时间段数据,并进行插入
                if(ins_m.quantumData.quantumList.length > 0){
                    if(ins_m.quantumData.insertIndex < ins_m.quantumData.quantumList.length){
                        ins_m.quantumData.insertIndex ++;
                        ins_m.insertOneQuantumData();
                    }
                }
            });
        }
    }
    if(msg != ""){
        this.showMsg(msg);
        ins_m.flg.autoInsertFlg = false;
    }
}

ins_m.insertNewGpsDatas = function(){
    let that = this;
    let msg = "";
    let resList = InsertGps.cache.gpsList;
    let statusData = InsertGps.cache.statusData;
    if(resList.length <= 0){
        msg += "获取gps轨迹数据失败，请重试！" + InsertGps.cache.errorMsg;
    }else{
        //获取转发标记
        let param = {};
        msg += that.setTransValue(param);
        msg += InsertGps.cache.errorMsg;//错误信息
        //开始请求
        if(msg == ""){
            //GPS数据
            param.plateNo = statusData.plateNo;
            param.simNo = statusData.simNo;
            param.plateColor = statusData.plateColor;
            param.alarmState = 0;
            param.status = 790531;//车辆状态，Acc开（0），定位（1），车门枷锁（12），gps定位（18），北斗定位（19）
            param.gas = 0;
            param.valid = 1;//数据有效
            param.commandId = 0;
            param.gpsList = JSON.stringify(resList);//gps数据列表

            //用于记录日志信息的数据
            param.insertCreateDate = Utility.dateToString(new Date());
            param.insertSatrtDate = InsertGps.cache.start.time;
            param.insertEndDate = InsertGps.cache.end.time;



            let url = globalConfig.webPath + "/insertAndTrans/insertGpsDatas.action";
            that.outDebug("需要插入的参数：",param);
            $("#ins_m_cal_insertGpsData").attr("disabled","disabled");
            that.showMsg("开始插入数据.......");
            Utility.getAjaxData(url,JSON.stringify(param),function(data){
                that.outDebug("接收到插入gps数据响应：", data);
                if(data.success){
                    let str = "";
                    if(DataUtil.isDefined(param.transFlg)){
                        str = "本次不允许809转发!";
                    }
                    str =  "  " + data.message + "插入的gps定位数据数量为：" +data.data + "条!" + str;
                    that.showMsg(str);
                    //开始更新状态
                    that.deleteOneDisData(str);
                }else{
                    that.showMsg("  " +data.message);
                }
                ins_m.flg.autoInsertFlg = false;
            });
        }
    }
    if(msg != ""){
        this.showMsg(msg);
        ins_m.flg.autoInsertFlg = false;
    }
}


//设置转发相关数据
ins_m.setTransValue = function(param){
    let msg = "";
    let insertFlg = $("#ins_m_insertFlg_check").is(":checked");
    let transFlgOld = $("#ins_m_transOld_check").is(":checked");
    let transFlgNew = $("#ins_m_transNew_check").is(":checked");
    // this.outDebug("插入数据库标记：" + insertFlg + " , 旧809转发标记：" + transFlgOld + "  , 新809转发标记：" + transFlgNew);

    //插入数据库标记,同转发标记
    if(insertFlg == true){
        param.insertFlg = true;
    }

    //--------------------转发数据标记，如果不转发，则不需要插入该值,转发只判断参数中有无transFlg参数
    //转发标记
    if(transFlgOld && transFlgNew){
        msg += "转发新平台和转发旧平台不能同时选中!";
    }else{
        if(transFlgOld){
            param.transFlg = true;
            param.transType = "old";
            param.transUrl = "rmi://222.187.86.139:10099/transferService";
        }else if(transFlgNew){
            param.transFlg = true;
            param.transType = "new";
            param.transUrl = "rmi://222.187.86.218:18800/transferService";
        }
    }

    return msg;
}

//校验速度合法性
ins_m.checkSpeedValue = function(){
    let msg = "";
    try {
        let speed = isNaN(parseInt($("#ins_m_cal_speed").val())) ? -1 : parseInt($("#ins_m_cal_speed").val());
        if(speed < 0){
            msg += "获取速度数值失败！";
        }else if(speed > 0){
            if(speed >= ins_m.flg.maxSpeedFlg){
                msg += "平均速度值大于" + ins_m.flg.maxSpeedFlg + "公里，不建议补轨迹！";
            }
        }
    } catch (error) {
        msg += "校验速度合法性失败："  + error;
    }
    return msg;
}

// 假删除一条不连续轨迹数据
ins_m.deleteOneDisData = function(str){
    let that = this;
    let disId = isNaN(parseInt("${disId}")) ? 0 : parseInt("${disId}");
    if(disId > 0){
        let param = {};
        param.updateFlg = 'inserted';
        param.Id = disId;
        param.queryId = "dataProcess.delOneDisconData";

        let url = globalConfig.webPath + "/basicSlctAction/basicSelectData.action";
        Utility.getAjaxData(url,JSON.stringify(param),function(data){
            if(data.success){
                str += "更新不连续轨迹GPS数据为已补数据状态!";
            }else{
                str += data.message;
            }
            that.updateTimeLineData(str);
            that.showMsg(str);
        });
    }
}

//更新时间线数据
ins_m.updateTimeLineData = function(str){
    let that = this;
    let resList = InsertGps.cache.gpsList;
    if(resList.length > 0){
        let startObj = resList[0];
        let endObj = resList[resList.length -1];
        if(!DataUtil.isDefined(startObj) && !DataUtil.isDefined(endObj)){
            let param = {};
            param.timeOffset = 3* 60;//时间偏移量，超过这个时间的不查询不校验
            param.plateNo = startObj.plateNo;
            param.simNo = startObj.simNo;
            
            //起点数据
            param.startDate = startObj.sendTime;
            param.startLatitude = startObj.latitude;
            param.startLongitude = startObj.longitude;
            param.startMileage = startObj.mileage;
            param.startVelocity = startObj.speed;
            param.startAcc = 1;
            //终点数据
            param.endDate = endObj.sendTime;
            param.endLatitude = endObj.latitude;
            param.endLongitude = endObj.longitude;
            param.endMileage = endObj.mileage;
            param.endVelocity = endObj.speed;
            param.endAcc = 1;

            let url = globalConfig.webPath + "/insertAndTrans/updateGpsTimeLine.action";
            Utility.getAjaxData(url, JSON.stringify(param), function (data) {
                ins_m.outDebug("接收到更新校验时间线响应数据：", data);
                if (data.success) {
                    str += "更新时间线数成功！";
                } else {
                    str += data.message;
                }
                that.showMsg(str)
            });
        }
    }else{
        str += "GPS轨迹数据不存在，无法更新时间线数据！";
        that.showMsg(str);
    }
}

/////////////////////////////////////////////////////////////////控件事件

//获取时间数值
ins_m.getNowTimeStr = function(index){
    let str = '';
    switch (index) {
        case 0:
            str = Utility.today() + ' 00:00:00';
            $("#ins_m_startDate").datetimebox("setValue",str);
            break;
        case 1:
            str = Utility.today() + ' 23:59:59';
            $("#ins_m_endDate").datetimebox("setValue",str);
            break;
        case 2://车机开始时间
            $("#ins_m_cal_startDate").val($("#ins_m_startDate").datetimebox("getValue"));
            break;
        case 3://车机结束时间
            $("#ins_m_cal_endDate").val($("#ins_m_endDate").datetimebox("getValue"));
            break;
    }

}


//查询车辆起点终点按钮点击事件
ins_m.getVehPoint = function(){
    //初始化onlyTrans相关数据
    ins_m.onlyTrans.cache = {};//清空onlyTrans缓存
    //开始查询
    if(this.flg.searchFlg == 0){
        let that = this;
        let param = ins_m.getSearchParam();
        if(param.message == ""){
            //开始查询
            // this.outDebug("开始查询！");
            ins_m.showMsg("正在查询......");
            this.flg.searchFlg = 1;//设置查询标记
            let url = globalConfig.webPath + '/basicSlctAction/basicSelectData.action';
            Utility.getAjaxData(url,JSON.stringify(param),function(data){
                that.outDebug("接收到查询结果：" , data);
                if(data.success){
                    that.showMsg("查询成功！");
                    $("#ins_m_slctDatagrid_tab").datagrid("loadData",data.data);
                    if(data.data.length == 0){
                        that.showMsg("本次查询没有查询到轨迹数据！")
                    }
                }else{
                    that.showMsg(data.message);
                }
                that.flg.searchFlg = 0;//重置查询标记
            });
        }else{
            ins_m.showMsg(param.message);
    
        }
    }else{
        this.showMsg("正在查询，请不要重复点击！")
    }
}

//获取查询参数
ins_m.getSearchParam = function(){
    let param = {message:""};
    param.queryId = "insertAndTrans.selectGpsData";
    let plateNo = $("#ins_m_plateNo_input").val();
    if(plateNo != ""){
        param.plateNo = plateNo;
    }

    let startDate = $("#ins_m_startDate").datetimebox("getValue");
    if(startDate != ""){
        param.startDate = startDate;
    }
    let endDate = $("#ins_m_endDate").datetimebox("getValue");
    if(endDate != ""){
        param.endDate = endDate;
    }
    return param;
}


//规划路径按钮点击事件
ins_m.getBaiduRoute = function(){
    if(baiduDriving != null){
        let msg = "";
        let p1lng = parseFloat($("#ins_m_point1_lng_input").val());
        if(!isNaN(p1lng)){
            p1lng = p1lng.toFixed(6);
        }else{
            msg += "起点经度不合法！";
        }
        let p1lat = parseFloat($("#ins_m_point1_lat_input").val());
        if(!isNaN(p1lat)){
            p1lat = p1lat.toFixed(6);
        }else{
            msg += "起点纬度不合法！";
        }

        let p2lng = parseFloat($("#ins_m_point2_lng_input").val());
        if(!isNaN(p2lng)){
            p2lng = p2lng.toFixed(6);
        }else{
            msg += "终点经度不合法！";
        }
        let p2lat = parseFloat($("#ins_m_point2_lat_input").val());
        if(!isNaN(p2lat)){
            p2lat = p2lat.toFixed(6);
        }else{
            msg += "终点纬度不合法！";
        }
        // let p1 = new BMap.Point(115.141892, 37.371045);//起点
        // let p2 = new BMap.Point(114.758943, 37.982258);//终点
        if(msg == ""){
            this.showMsg("正在规划路径，请稍后......");
            ins_m.calRoutdatas(p1lng, p1lat, p2lng, p2lat);
        }else{
            this.showMsg(msg);
        }
        // this.outDebug("正在计算路径，请稍后......");
    }else{
        this.outDebug("路径规划对象为null，无法进行路径规划！");
    }
}


ins_m.showCourseHmtl = function(){
    let url = "<%=ApplicationPath%>/html/insertGpsDataCourse.html";
    // let parent = window.parent;
    // if(!DataUtil.isDefined(parent)){
    //     parent.addTab("教程")
    // }
    InfoWindow.open(url,800,600,"gps数据补轨迹教程");
}

//只转发数据
ins_m.onlyTransBtnClick = function(){
    let that = this;
    let param = ins_m.getOnlyTransParam();
    let str =  "起止时间：" + param.startDate + " - " + param.endDate + "，是否转发数据库中当前时间段内的数据至政府平台？";
    $.messager.confirm('确认', str, function (res) {
            if(res){
                let url = globalConfig.webPath + "/insertAndTrans/transMyData.action";
                Utility.getAjaxData(url,JSON.stringify(param),function(data){
                    if(data.success){
                        that.showMsg("转发成功！")
                    }else{
                        that.showMsg(data.message);
                    }
                });
            }
        });
    
}

//获取纯转发参数
ins_m.getOnlyTransParam = function(){
    let param = {message:""};
    param.startDate = $("#ins_m_startDate").datetimebox("getValue");
    param.endDate = $("#ins_m_endDate").datetimebox("getValue");
    if(DataUtil.isDefined(param.startDate)){
        param.message += "开始时间不能为空！";
    }
    if(DataUtil.isDefined(param.endDate)){
        param.message += "结束时间不能为空！";
    }
    return param;
}
/////////////////////////////////////////////////////////////////公用方法
//输出调试信息
ins_m.outDebug = function(msg,data){
    if(ins_m.debug == true){
        DataUtil.outDebug(msg,data);
    }
}

//显示信息,30秒后自动清空
ins_m.showMsg = function(msg){
    $('body').stopTime(ins_m.msgTimer);
    $("#ins_m_msg_div").val(msg);
    $('body').oneTime("60s",ins_m.msgTimer,function(){
        $("#ins_m_msg_div").val("");
    });
}

/////////////////////////////////////////////////////////////////加载后执行
$(document).ready(function(){
    DataUtil.outDebug("ready");
    ins_m.initDivs();//初始化控件
    ins_m.initDatas();//初始化数据
});


/////////////////////////////////////////////////////////////////测试数据
//测试数据
ins_m.testBtnFun = function(){
    ins_m.outDebug('开始进行测试.....');
    let param = {};
    param.timeOffset = 3* 60;//时间偏移量，超过这个时间的不查询不校验
    //开始结束时间
    param.startDate = $("#ins_m_startDate").datetimebox("getValue");
    param.endDate = $("#ins_m_endDate").datetimebox("getValue");
    //车牌号
    param.plateNo = $("#ins_m_plateNo_input").val();
    param.simNo = '12345678910';

    //起点数据
    param.startLongitude = '115.111111';
    param.startLatitude = '34.111111';
    param.startVelocity = 76.11;
    param.startAcc = 1;
    param.startMileage = 89111.1;
    //终点数据
    param.endLongitude = '116.222222';
    param.endLatitude = '34.222222';
    param.endVelocity = 76.22;
    param.endAcc = 1;
    param.endMileage = 89222.2;

    let url = globalConfig.webPath + "/insertAndTrans/updateGpsTimeLine.action";
    Utility.getAjaxData(url,JSON.stringify(param),function(data){
        ins_m.outDebug("接收到查询校验时间线数据：",data);
        if(data.success){
            DataUtil.showMsg(data.message);
        }else{
            DataUtil.showErrorMsg(data.message);
        }
    });
}

</script>




</head>
<body>
    <div class="" style="width:100%;height:100%;min-width:1000px;min-height:710px;overflow:auto;display: flex;font-size:14px;">
        <!--左侧区域-->
        <div style="width:600px;height: 100%;" class="base_ver_flexStartDiv_css ">
            <textarea id="ins_m_msg_div" style="height:50px;width:100%;margin-top:3px;overflow: auto;color:red;font-size: 12px;">

            </textarea>
            <!-- <div id="ins_m_msg_div" style="height:50px;width:98%;margin-top:3px;overflow: auto;color:red;font-size: 12px;" class="base_hori_flexCenterDiv_css">
            </div> -->
            <div id="ins_m_baiduMap_Div" style="width:100%;height:320px;margin-bottom:10px;border:1px solid rgb(228,228,228);border-radius: 3px;">
        
            </div>
            <table id="ins_m_calData_tab" style="width:100%;height:310px;margin-top:5px;">
            </table>
        
        </div>
        <!--右侧区域-->
        <div style="width:500px;height:695px;margin-left:2px;" class="base_ver_flexStartDiv_css base_border228_css">
            <!--工具区域-->
            <div class="ins_m_toolParDiv_css"> 
                <div style="justify-content:flex-start;margin-top: 5px;">
                    <span>车牌号码：</span>
                    <input id="ins_m_plateNo_input" type="text" placeholder="输入车牌号,支持模糊查询" ondblclick="this.value='苏C';" class="ins_m_inputImpBorder_css"
                    style="width:160px;">
                    <a  href="#" class="easyui-linkbutton" data-options="iconCls:'icon-search'" 
                    style="margin-left:10px;width:70px;" onclick="ins_m.getVehPoint();">查询</a>&nbsp;
                    <a  href="#" class="easyui-linkbutton" data-options="iconCls:'icon-search'" 
                    style="margin-left:10px;width:70px;" onclick="ins_m.onlyTransBtnClick();">仅转发</a>
                    <a  href="#" class="easyui-linkbutton" data-options="iconCls:'icon-search'" 
                    style="margin-left:10px;display: none;" onclick="ins_m.testBtnFun();">测试功能</a>
                </div>
                <div style="justify-content:flex-start;">
                    <span>起止时间：</span>
                    <input id="ins_m_startDate" type="text" class="easyui-datetimebox ins_m_inputImpBorder_css" 
                    style="width:150px;" ondblclick="ins_m.getNowTimeStr(0);">
                    <span>&nbsp;&nbsp;-&nbsp;&nbsp;</span>
                    <input id="ins_m_endDate" type="text" class="easyui-datetimebox ins_m_inputImpBorder_css" 
                    style="width:150px;" ondblclick="ins_m.getNowTimeStr(1);">
                </div>
                <!--坐标点选择框-->
                <div style="width:96%;height:185px;margin-top:10px;">
                    <table id="ins_m_slctDatagrid_tab" style="width:96%;height:100%;">
    
                    </table>
                </div>


                <!--参数设置区-->
                <div class="base_ver_Center_leftDiv_css">
                    <div style="width:100%;margin-top:0px;">
                        <span>参数设置区------------------------</span>
                        <a href="javascript:ins_m.showCourseHmtl();">(教程)</a>
                    </div>
                </div>
                <div style="justify-content:flex-start;">
                    <input id="ins_m_insertFlg_check" type="checkbox" checked="checked"><span>插入数据库</span><!--checked="checked"-->
                    &nbsp;&nbsp;
                    <input id="ins_m_transOld_check" type="checkbox" ><span>转发旧809平台</span>
                    &nbsp;&nbsp;
                    <input id="ins_m_transNew_check" type="checkbox" checked="checked"><span>转发新809平台</span>
                    &nbsp;&nbsp;
                    <input id="ins_m_noDrive2to5" type="checkbox" checked="checked"><span>2点到5点禁行</span>
                </div>
                <!--车牌号码，simNo-->
                <div style="justify-content:flex-start;">
                    <span>车牌号码：</span>
                    <input id="ins_m_cal_plateNo" type="text" style="width:90px;" class="ins_m_inputImpBorder_css">
                    &nbsp;&nbsp;&nbsp;
                    <span>simNo：</span>
                    <input id="ins_m_cal_simNo" type="text" style="width:110px;" class="ins_m_inputImpBorder_css">
                </div>
                <!--车牌颜色-->
                <div style="justify-content:flex-start;">
                    <span>车牌颜色：</span>
                    <input id="ins_m_cal_plateColor" type="text" style="width:50px;" class="ins_m_inputImpBorder_css" value="2">
                    &nbsp;&nbsp;&nbsp;
                    <span>(0：未录入，1：蓝色，2：黄色,6：黄绿)</span>
                </div>
                <!--坐标点区-->
                <div style="justify-content:flex-start;">
                    <span>起点：&nbsp;&nbsp;经度：</span>
                    <input id="ins_m_point1_lng_input" type="text" style="width:110px;" class="ins_m_inputImpBorder_css">
                    <span>&nbsp;&nbsp;&nbsp;--&nbsp;&nbsp;&nbsp;</span>
                    <span>纬度：</span>
                    <input id="ins_m_point1_lat_input" type="text" style="width:110px;" class="ins_m_inputImpBorder_css">
                </div>
                <div style="justify-content:flex-start;">
                    <span>终点：&nbsp;&nbsp;经度：</span>
                    <input id="ins_m_point2_lng_input" type="text" style="width:110px;" class="ins_m_inputImpBorder_css">
                    <span>&nbsp;&nbsp;&nbsp;--&nbsp;&nbsp;&nbsp;</span>
                    <span>纬度：</span>
                    <input id="ins_m_point2_lat_input" type="text" style="width:110px;" class="ins_m_inputImpBorder_css">
                </div>

                
                <div style="justify-content:flex-start;">
                    <span>车机时间：&nbsp;</span>
                    <input id="ins_m_cal_startDate" type="text" class="easyui-datetimebox ins_m_inputImpBorder_css" 
                    style="width:150px;" ondblclick="ins_m.getNowTimeStr(2);">
                    <span>&nbsp;&nbsp;-&nbsp;&nbsp;</span>
                    <input id="ins_m_cal_endDate" type="text" class="easyui-datetimebox ins_m_inputImpBorder_css" 
                    style="width:150px;" ondblclick="ins_m.getNowTimeStr(3);">
                </div>
                <div class="base_ver_Center_leftDiv_css">
                    <div style="width:100%;margin-top:0px;">
                        <span>接收时间：</span>
                        <input id="ins_m_cal_createDate" type="text" class="easyui-datetimebox ins_m_inputImpBorder_css" 
                        style="width:150px;" >
                    </div>
                    <div style="width:100%;margin-top:5px;display: none;">
                        
                        
                    </div>
                    <div style="width:100%;margin-top:8px;">
                        <span>总里程：&nbsp;</span>
                        <span id="ins_m_cal_miles"></span>
                        <span>&nbsp;(Km)</span>
                        <span>&nbsp;耗时：&nbsp;</span>
                        <span id="ins_m_cal_time"></span>
                        <span>&nbsp;(分钟)</span>
                        <span>平均车速：</span>
                        <input id="ins_m_cal_speed" type="text" style="width:50px;" class="ins_m_inputImpBorder_css" >
                        <span>(Km/h)&nbsp;</span>
                        
                    </div>
                    
                    <div style="width:100%;margin-top:8px;display: none;">
                        <span>总体方向：</span>
                        <input id="ins_m_cal_direction" type="text" style="width:110px;" class="ins_m_inputImpBorder_css" value="0">
                        <span>(0-359度，正北方向为0度，顺时针递增)</span>
                    </div>
                    <div style="width:100%;margin-top:8px;">
                        <span>平均海拔：</span>
                        <input id="ins_m_cal_altitude" type="text" style="width:50px;" class="ins_m_inputImpBorder_css" value="30">
                        <span>(米)&nbsp;</span>
                        <span>最高限速：</span>
                        <input id="ins_m_cal_maxSpeed" type="text" style="width:50px;" class="ins_m_inputImpBorder_css" value="80">
                        <span>(Km/h)</span>
                    </div>
                    <div style="width:100%;margin-top:0px;">
                        <span>-----------------------------------</span>
                    </div>
                </div>
                


                <!--按钮区-->
                <div style="justify-content:center;margin-top:5px;margin-bottom: 10px;">
                    <a href="#" class="easyui-linkbutton" data-options="iconCls:'icon-ok'" style="margin-left:10px;width:100px;"
                        onclick="ins_m.getBaiduRoute();">路径规划</a>
                
                    <a href="#" class="easyui-linkbutton" data-options="iconCls:'icon-edit'" style="margin-left:10px;width:110px;margin-left:10px;display: none;"
                        onclick="ins_m.fomratCaledRoutDatas();">轨迹数据计算</a>

                    <a id="ins_m_cal_insertGpsData" href="#" class="easyui-linkbutton" data-options="iconCls:'icon-ok'"
                     style="margin-left:10px;width:110px;" onclick="ins_m.insertGpsBeforeCheck();" >插入或者转发</a>
                </div>
            </div>
        </div>
    </div>
</body>